package com.cloudsea.yunhaistores.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.lang.Snowflake;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.cloudsea.yunhaistores.dto.SpuAddDTO;
import com.cloudsea.yunhaistores.dto.SpuUpdateDTO;
import com.cloudsea.yunhaistores.entity.Categories;
import com.cloudsea.yunhaistores.entity.Skus;
import com.cloudsea.yunhaistores.entity.Spus;
import com.cloudsea.yunhaistores.mapper.CategoriesMapper;
import com.cloudsea.yunhaistores.mapper.SkusMapper;
import com.cloudsea.yunhaistores.mapper.SpusMapper;
import com.cloudsea.yunhaistores.service.SpuService;
import com.cloudsea.yunhaistores.vo.SpuDetailVO;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
import java.util.List;

@Service
public class SpuServiceImpl implements SpuService {

    @Autowired
    private SpusMapper spusMapper;

    @Autowired
    private SkusMapper skusMapper;

    @Autowired
    private CategoriesMapper categoriesMapper; // 注入CategoriesMapper

    @Autowired
    private Snowflake snowflake;

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Override
    @Transactional // 保证SPU和SKU的创建是原子操作
    public Spus addSpu(SpuAddDTO dto) {
        // 安全校验：检查操作员是否有权为该门店添加商品 (此处简化，逻辑同clearTable)
        StpUtil.checkLogin(); // 至少确保是登录状态

        // 1. 处理分类：如果分类不存在，则为该门店创建一个新分类
        QueryWrapper<Categories> cq = new QueryWrapper<>();
        cq.eq("store_id", dto.getStoreId()).eq("name", dto.getCategoryName());
        Categories category = categoriesMapper.selectOne(cq);
        if (category == null) {
            category = new Categories();
            category.setId(snowflake.nextId());
            category.setStoreId(dto.getStoreId());
            category.setName(dto.getCategoryName());
            category.setCreatedAt(LocalDateTime.now());
            category.setUpdatedAt(LocalDateTime.now());
            categoriesMapper.insert(category);
        }

        // 2. 创建SPU (商品主体)
        Spus spu = new Spus();
        long spuId = snowflake.nextId();
        spu.setId(spuId);
        spu.setStoreId(dto.getStoreId());
        spu.setSpuName(dto.getSpuName());
        spu.setCategoryName(dto.getCategoryName()); // 直接使用分类名
        spu.setSpuDescription(dto.getSpuDescription());
        spu.setSpuImageUrl(dto.getSpuImageUrl());
        spu.setStatus(1); // 默认直接上架
        // 将第一个SKU的价格设为SPU的默认价
        spu.setDefaultPrice(dto.getSkus().get(0).getPrice());
        spu.setCreatedAt(LocalDateTime.now());
        spu.setUpdatedAt(LocalDateTime.now());
        spusMapper.insert(spu);

        // 3. 遍历并创建所有SKU (商品规格)
        for (SpuAddDTO.SkuAddDTO skuDto : dto.getSkus()) {
            Skus sku = new Skus();
            sku.setId(snowflake.nextId());
            sku.setSpuId(spuId); // 关联到刚刚创建的SPU
            sku.setSkuName(skuDto.getSkuName());
            sku.setPrice(skuDto.getPrice());
            sku.setStock(skuDto.getStock());
            sku.setSkuImageUrl(skuDto.getSkuImageUrl());
            sku.setSpecs(skuDto.getSpecs());
            sku.setStatus(1); // 默认上架
            sku.setCreatedAt(LocalDateTime.now());
            sku.setUpdatedAt(LocalDateTime.now());
            skusMapper.insert(sku);
        }

        // >>> 在方法返回前，调用缓存清理方法 <<<
        clearMenuCache(dto.getStoreId());
        return spu;
    }

    @Override
    public SpuDetailVO getSpuDetailById(Long spuId) {
        // 1. 查询SPU主体
        Spus spu = spusMapper.selectById(spuId);
        if (spu == null) {
            throw new RuntimeException("商品不存在");
        }

        // 2. 查询其下的所有SKU
        List<Skus> skus = skusMapper.selectList(new QueryWrapper<Skus>().eq("spu_id", spuId));

        // 3. 组装VO
        SpuDetailVO detailVO = new SpuDetailVO();
        BeanUtils.copyProperties(spu, detailVO); // 复制SPU的属性
        detailVO.setSkus(skus);

        return detailVO;
    }

    @Override
    @Transactional
    public void updateSpu(Long spuId, SpuUpdateDTO dto) {
        // 安全校验 (简化)
        StpUtil.checkLogin();

        // 1. 查询要修改的SPU
        Spus spu = spusMapper.selectById(spuId);
        if (spu == null) {
            throw new RuntimeException("商品不存在");
        }

        // 2. 使用BeanUtils选择性地复制非空字段
        BeanUtils.copyProperties(dto, spu, "storeId"); // 复制属性，但忽略 storeId
        spu.setUpdatedAt(LocalDateTime.now());

        // 3. 执行更新
        spusMapper.updateById(spu);

        // 在方法结束前，调用缓存清理方法
        clearMenuCache(spu.getStoreId());
    }

    @Override
    public IPage<Spus> listSpusByPage(Long storeId, int pageNum, int pageSize, String keyword) {
        // 1. 创建分页对象
        Page<Spus> page = new Page<>(pageNum, pageSize);

        // 2. 创建查询条件
        QueryWrapper<Spus> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("store_id", storeId);

        // 3. 如果有关键词，则进行模糊查询
        if (StringUtils.hasText(keyword)) {
            queryWrapper.like("spu_name", keyword);
        }

        // 4. 按更新时间倒序
        queryWrapper.orderByDesc("updated_at");

        // 5. 执行分页查询
        return spusMapper.selectPage(page, queryWrapper);
    }

    @Override
    @Transactional
    public void deleteSpu(Long spuId) {
        // 安全校验 (简化)
        StpUtil.checkLogin();

        // >>>【重要】在删除前，先查出SPU信息以获取storeId <<<
        Spus spuToDelete = spusMapper.selectById(spuId);
        if (spuToDelete == null) {
            throw new RuntimeException("商品不存在或已被删除");
        }

        // 1. 先删除该SPU下的所有SKU
        skusMapper.delete(new QueryWrapper<Skus>().eq("spu_id", spuId));

        // 2. 再删除SPU自身
        spusMapper.deleteById(spuId);

        // 在方法结束前，调用缓存清理方法
        clearMenuCache(spuToDelete.getStoreId());
    }

    /**
     * 清理指定门店的菜单缓存
     * @param storeId 门店ID
     */
    private void clearMenuCache(Long storeId) {
        if (storeId == null) {
            return;
        }
        String cacheKey = "menu:store:" + storeId;
        redisTemplate.delete(cacheKey);
        // 可以在这里加一条日志，方便调试
        // log.info("已清理门店 [{}] 的菜单缓存。", storeId);
    }
}
